const User = require('../models/User');
const jwt = require('jsonwebtoken');
const nodemailer = require('nodemailer');
const crypto = require('crypto');
const path = require('path');
const NodeCache = require('node-cache');

// 初始化内存缓存
const cache = new NodeCache({ stdTTL: 300, checkperiod: 60 }); // 设置默认过期时间为 60 秒

// 角色权限映射
const rolePermissions = {
  student: ['read', 'comment', 'subscribe'],
  teacher: ['read', 'comment', 'publish', 'manage-class'],
  admin: ['all']
};

// 获取当前用户信息
exports.getMe = async (req, res, next) => {
  try {
    const user = await User.findById(req.user.id);
    
    if (!user) {
      return res.status(404).json({
        status: 'fail',
        message: '用户不存在'
      });
    }

    res.status(200).json({
      status: 'success',
      data: {
        user: {
          id: user._id,
          email: user.email,
          nickname: user.nickname,
          bio: user.bio,
          avatar: user.avatar || '/default-avatar.png',
          // 添加前端需要但后端缺失的字段
          isEditable: false, // 假设默认不可编辑
          showWorks: false,
          postPage: 1,
          postPageSize: 30,
          postTotal: 0,
          isPostLoading: false
        }
      }
    });
  } catch (err) {
    next(err);
  }
};

// 更新用户头像、昵称、简介（支持 multipart/form-data 和 application/json，头像支持 base64 或二进制）
exports.updateProfile = async (req, res, next) => {
  try {
    let nickname, bio, avatarBase64;
    if (req.is('multipart/form-data')) {
      nickname = req.body.nickname;
      bio = req.body.bio;
      avatarBase64 = req.body.avatar; // base64 字符串（可选）
    } else {
      nickname = req.body.nickname;
      bio = req.body.bio;
      avatarBase64 = req.body.avatar; // base64 字符串（可选）
    }
    // 查找当前登录用户
    const user = await User.findById(req.user.id);
    if (!user) {
      return res.status(404).json({
        status: 'fail',
        message: '用户不存在'
      });
    }
    if (nickname) user.nickname = nickname;
    if (bio !== undefined) user.bio = bio;
    // 只允许 base64 头像
    if (avatarBase64 && typeof avatarBase64 === 'string' && avatarBase64.startsWith('data:image/')) {
      user.avatar = avatarBase64;
      user.contentType = avatarBase64.substring(5, avatarBase64.indexOf(';'));
    }
    await user.save();
    res.status(200).json({
      status: 'success',
      data: { user }
    });
  } catch (err) {
    next(err);
  }
};

// 发送邮箱验证码
exports.sendVerificationCode = async (req, res, next) => {
    try {
        console.log('Received request for sendVerificationCode:', req.body);
        const { email } = req.body;
        if (!email) {
            return res.status(400).json({ status: 'fail', message: '邮箱不能为空' });
        }

        // 检查内存缓存中是否已存在未过期的验证码
        const existingCode = cache.get(email);
        if (existingCode) {
            return res.status(400).json({ status: 'fail', message: '验证码已发送，请勿重复请求' });
        }

        // 生成 4 位随机验证码
        const code = crypto.randomInt(1000, 9999).toString();

        // 将验证码存储到内存缓存，并设置 1 分钟过期时间
        cache.set(email, code, 60);

        // 配置邮件发送
        const transporter = nodemailer.createTransport({
            host: 'smtp.qq.com',
            port: 465,
            secure: true,
            auth: {
                user: process.env.EMAIL_USER,
                pass: process.env.EMAIL_PASS
            }
        });

        const mailOptions = {
            from: process.env.EMAIL_USER,
            to: email,
            subject: '您的验证码',
            text: `您的验证码是：${code}`
        };

        await transporter.sendMail(mailOptions);

        res.status(200).json({ status: 'success', message: '验证码已发送' });
    } catch (err) { 
        console.error('Error in sendVerificationCode:', err);
        next(err);
    }
};

// 比对验证码
exports.verifyCodeAndRegister = async (req, res, next) => {
    try {
        const { email, verificationCode, username, password } = req.body;

        // 从内存缓存获取验证码
        const storedCode = cache.get(email);
        if (storedCode !== verificationCode) {
            return res.status(400).json({ status: 'fail', message: '验证码错误或已过期' });
        }

        // 验证通过后删除验证码
        cache.del(email);

        res.status(201).json({ status: 'success', message: '验证成功', data: { user: newUser } });
    } catch (err) {
        next(err);
    }
};

// 用户注册
exports.Register = async (req, res, next) => {
    try {
        const { email, verificationCode, nickname, password, confirmPassword, avatar } = req.body;

        if (!email || !verificationCode || !nickname || !password || !confirmPassword) {
            return res.status(400).json({ message: '所有字段均为必填项' });
        }

        const user = await User.findOne({ email });
        if (user) {
            return res.status(400).json({ message: '该邮箱已注册' });
        }

        // 从内存缓存获取验证码
        const storedCode = cache.get(email);
        if (storedCode !== verificationCode) {
            return res.status(400).json({ message: '验证码错误或已过期' });
        }
        cache.del(email); // 验证通过后删除验证码

        let avatarBase64 = avatar;
        if (!avatarBase64) {
            // 读取默认头像文件并转为base64
            const fs = require('fs');
            const defaultAvatarPath = path.join(__dirname, '../config/default-avatar.png');
            const buffer = fs.readFileSync(defaultAvatarPath);
            avatarBase64 = 'data:image/png;base64,' + buffer.toString('base64');
        }

        const newUser = await User.create({
            email,
            nickname,
            password,
            avatar: avatarBase64,
            contentType: 'image/png' // 兼容旧逻辑
        });

        res.status(201).json({ message: '注册成功', data: newUser });
    } catch (error) {
        console.error('注册接口异常:', error);
        res.status(500).json({ message: error.message || '注册失败' });
    }
};

// 用户登录（邮箱+密码）
exports.loginWithEmailPassword = async (req, res, next) => {
    try {
        const { email, password } = req.body;

        if (!email || !password) {
            return res.status(400).json({ message: '请输入邮箱和密码' });
        }

        const user = await User.findOne({ email }).select('+password');
        if (!user) {
            return res.status(400).json({ message: '用户不存在' });
        }

        const isPasswordValid = await user.comparePassword(password);
        if (!isPasswordValid) {
            return res.status(400).json({ message: '密码错误' });
        }

        // 生成 JWT
        const token = jwt.sign({ id: user._id, role: user.role }, process.env.JWT_SECRET, { expiresIn: '1d' });

        // 返回 JWT 和用户信息
        res.status(200).json({ 
            message: '登录成功', 
            token, 
            data: {
                id: user._id,
                email: user.email,
                role: user.role,
                nickname: user.nickname,
                avatar: user.avatar
            }
        });
    } catch (error) {
        next(error);
    }
};

// 用户登录（邮箱+验证码）
exports.loginWithEmailVerification = async (req, res, next) => {
    try {
        const { email, verificationCode } = req.body;

        if (!email || !verificationCode) {
            return res.status(400).json({ message: '请输入邮箱和验证码' });
        }

        const user = await User.findOne({ email });
        if (!user) {
            return res.status(400).json({ message: '用户不存在' });
        }

        const storedCode = cache.get(email); // 使用 cache 对象获取验证码
        if (storedCode !== verificationCode) {
            return res.status(400).json({ message: '验证码错误或已过期' });
        }
        cache.del(email); // 验证通过后删除验证码

        // 生成 JWT
        const token = jwt.sign({ id: user._id, role: user.role }, process.env.JWT_SECRET, { expiresIn: '1d' });

        // 返回 JWT 和用户信息
        res.status(200).json({ 
            message: '登录成功', 
            token, 
            data: {
                id: user._id,
                email: user.email,
                role: user.role,
                nickname: user.nickname,
                avatar: user.avatar
            }
        });
    } catch (error) {
        next(error);
    }
};


// 重置密码
exports.resetPassword = async (req, res, next) => {
    try {
        const { email, verificationCode, newpassword} = req.body;

        // 日志：打印收到的参数和缓存中的验证码
        //console.log('[重置密码] 参数:', { email, verificationCode, newpassword });
        //console.log('[重置密码] 缓存验证码:', cache.get(email));

        // 校验必填字段
        if (!email || !verificationCode || !newpassword) {
            return res.status(400).json({ 
                status: 'fail',
                message: '所有字段均为必填项' 
            });
        }

        // 查找用户
        const user = await User.findOne({ email });
        if (!user) {
            return res.status(400).json({ 
                status: 'fail',
                message: '用户不存在' 
            });
        }

        // 校验验证码
        const storedCode = cache.get(email); 
        console.log('[重置密码] 校验:', { received: verificationCode, stored: storedCode });
        if (storedCode !== verificationCode) {
            console.error('验证码错误:', { received: verificationCode, stored: storedCode });
            return res.status(400).json({ 
                status: 'fail',
                message: '验证码错误或已过期' 
            });
        }

        // 清除验证码并更新密码
        cache.del(email); 
        user.password = newpassword;
        await user.save();

        res.status(200).json({
            status: 'success',
            message: '密码已重置'
        });

    } catch (error) {
        if (error.name === 'ValidationError') {
            return res.status(400).json({ 
                status: 'fail',
                message: '数据验证失败' 
            });
        }
        next(error);
    }
};

// 身份认证
exports.identityVerification = async (req, res, next) => {
    try {
        const { role, department, studentId } = req.body;

        const user = await User.findById(req.user.id);
        if (!user) {
            return res.status(404).json({ message: '用户不存在' });
        }

        // 设置用户角色
        user.role = role;

        // 根据角色设置其他字段
        if (role === 'teacher') {
            user.department = department;
        } else if (role === 'student') {
            user.studentId = studentId;
        }

        await user.save();

        res.status(200).json({ message: '身份认证成功', data: user });
    } catch (error) {
        next(error);
    }
};

// 修改密码
exports.updatePassword = async (req, res, next) => {
    try {
        const { oldPassword, newPassword } = req.body;
        if (!oldPassword || !newPassword) {
            return res.status(400).json({ message: '旧密码和新密码都不能为空' });
        }

        // 验证旧密码
        const user = await User.findById(req.user.id).select('+password'); // 显式加载密码字段
        if (!user) {
            return res.status(404).json({ message: '用户不存在' });
        }

        const isPasswordValid = await user.comparePassword(oldPassword);
        if (!isPasswordValid) {
            return res.status(400).json({ message: '旧密码不正确' });
        }

        // 验证新密码是否符合要求（例如：长度至少6位）
        if (newPassword.length < 6) {
            return res.status(400).json({ message: '新密码长度至少为6位' });
        }

        // 更新密码
        user.password = newPassword;
        await user.save();

        res.status(200).json({ message: '密码修改成功' });
    } catch (error) {
        console.error('修改密码失败:', error);
        res.status(500).json({ message: '修改密码失败，请稍后重试' });
    }
};

// 更新用户昵称
exports.updateNickname = async (req, res) => {
    try {
        const { nickname } = req.body;
        if (!nickname) {
            return res.status(400).json({ message: '昵称不能为空' });
        }

        const user = await User.findById(req.user.id);
        if (!user) {
            return res.status(404).json({ message: '用户不存在' });
        }

        user.nickname = nickname;
        await user.save();

        res.status(200).json({
            status: 'success',
            data: {
                user
            }
        });
    } catch (error) {
        console.error('更新用户昵称失败:', error);
        res.status(500).json({
            status: 'fail',
            message: '更新用户昵称失败，请稍后重试'
        });
    }
};

// 更新用户头像
exports.updateAvatar = async (req, res) => {
    try {
        if (!req.file) {
            return res.status(400).json({ message: '请上传头像文件' });
        }

        const user = await User.findById(req.user.id);
        if (!user) {
            return res.status(404).json({ message: '用户不存在' });
        }

        user.avatar = req.file.buffer; // 保存图片的二进制数据
        user.contentType = req.file.mimetype; // 保存图片的 MIME 类型
        await user.save();

        res.status(200).json({
            status: 'success',
            data: {
                user
            }
        });
    } catch (error) {
        console.error('更新用户头像失败:', error);
        res.status(500).json({
            status: 'fail',
            message: '更新用户头像失败，请稍后重试'
        });
    }
};

// 获取用户头像
exports.getAvatar = async (req, res) => {
    try {
        const user = await User.findById(req.params.userId);
        if (!user || !user.avatar) {
            return res.status(404).json({
                status: 'fail',
                message: '用户头像不存在'
            });
        }
        res.set('Content-Type', user.contentType || 'image/png'); // 设置默认内容类型
        res.send(user.avatar);
    } catch (error) {
        console.error('获取用户头像失败:', error);
        res.status(500).json({
            status: 'fail',
            message: '获取用户头像失败，请稍后重试'
        });
    }
};

// 获取指定用户信息（含公开信息）
exports.getProfile = async (req, res) => {
    try {
        const user = await User.findById(req.params.userId).select('nickname bio avatar email');
        if (!user) {
            return res.status(404).json({ message: '用户不存在' });
        }
        res.status(200).json({
            code: 200,
            data: {
                id: user._id,
                nickname: user.nickname,
                bio: user.bio,
                avatar: user.avatar ? `/api/user/${user._id}/avatar` : '/default-avatar.png',
                email: user.email
            }
        });
    } catch (error) {
        res.status(500).json({ message: '获取用户信息失败' });
    }
};

// 获取指定用户的作品（分页）
exports.getUserPosts = async (req, res) => {
    try {
        const userId = req.params.userId;
        const page = parseInt(req.query.page) || 1;
        const pageSize = parseInt(req.query.pageSize) || 30;
        const total = await require('../models/Post').countDocuments({ author: userId });
        const posts = await require('../models/Post').find({ author: userId })
            .sort({ createdAt: -1 })
            .skip((page - 1) * pageSize)
            .limit(pageSize);
        res.status(200).json({
            code: 200,
            data: posts,
            total,
            page,
            pageSize
        });
    } catch (error) {
        res.status(500).json({ message: '获取用户作品失败' });
    }
};
